5.5 Enumerationen (Aufzählungen)  
Eine Enumeration ist von der Klasse Enum abgeleitet und als Gruppierung mehrerer Konstanten zu verstehen, die zur Laufzeit nicht verändert werden können. Alle in einer Enumeration enthaltenen Konstanten sind vom gleichen Datentyp. Dabei kann es sich um Byte, Short, Integer oder Long handeln, andere sind nicht zugelassen. Die Angabe des Typs der Enumeration erfolgt in der Deklaration. Betrachten Sie dazu das folgende Beispiel der Auflistung Spielkarte:
| Public Enum Spielkarte As Byte
|
| Karo = 9
|
| Herz = 10
|
| Pik = 11
|
| Kreuz = 12
|
| End Enum
|
Eine Enumeration wird mit dem Schlüsselwort Enum unter Voranstellung eines Zugriffsmodifizierers eingeleitet und mit End Enum abgeschlossen. Hinter der Angabe des Bezeichners kann optional der Datentyp aller der in der Auflistung enthaltenen Konstanten angegeben werden. Wird auf die Angabe verzichtet, handelt es sich standardmäßig um Integer-Konstanten. Der von den Konstanten repräsentierte Wert kann ausdrücklich zugewiesen werden, ansonsten wird er automatisch vergeben. In letzterem Fall steht das erste Element für den Wert 0, der sich mit jedem Folgeelement um +1 erhöht. Andererseits können bei einer expliziten Wertzuweisung die Konstantenwerte auch negativ sein. Beachten Sie, dass bei einer expliziten Wertzuweisung der Wert als Basis für die Nummerierung aller Folgeelemente benutzt wird:
| Public Enum TestEnum
|
| a = –2
|
| b
|
| c
|
| End Enum
|
Da das erste Element (a) für den Konstantenwert –2 steht, gilt für das Folgeelement (b) der Wert –1 und für das letzte Element (c) schließlich 0. Selbstverständlich muss bei einer durchweg expliziten Angabe der Konstantenwerte keine Reihenfolge eingehalten werden. Andererseits dürfen unterschiedlich Enum-Elemente durchaus dieselben Werte repräsentieren.
Eine Enumeration wird von der Common Language Runtime wie ein Wertetyp behandelt. Daher ist eine Variablendeklaration notwendig, um Nutzen aus der Auflistung zu ziehen:
Die Variable myGame kann nun für ein beliebiges Element der Auflistung stehen. Um welches es sich genau handeln soll, muss nachfolgend mit der Punktnotation bekannt gegeben werden.
Eine andere Variante ist, einer beliebigen, ganzzahligen Variablen den Wert einer auf einem Enum-Typen basierenden Variablen zuweisen:
| Dim myGame As Spielkarte
|
| Dim intVar As Integer
|
| intVar = myGame.Karo
|
Sollte es erforderlich sein, können Sie Strukturen auch ineinander verschachteln. Die einzelnen Ebenen werden – wie üblich – durch Punktnotation voneinander getrennt.
5.5.1 Alle Mitglieder einer Aufzählung durchlaufen 
Enumerationen werden uns im zweiten Teil dieses Buches, wenn wir uns der Programmierung von Windows-Anwendungen widmen, häufig begegnen. Dabei wird es manchmal sinnvoll sein, die Mitglieder einer Aufzählung in einer Schleife abzugreifen. Ich möchte Ihnen am Beispiel der Aufzählung Spielkarte demonstrieren, wie das programmiertechnisch realisiert wird.
| ' --------------------------------------------------------------
|
| ' Beispiel: ...\Kapitel 5\Enumeration
|
| ' --------------------------------------------------------------
|
| Module Module1
|
| Sub Main()
|
| Dim karte As Spielkarte
|
| For Each karte In [Enum].GetValues(GetType(Spielkarte))
|
| Console.WriteLine(karte.ToString())
|
| Next
|
| Console.ReadLine()
|
| End Sub
|
| End Module
|
| Public Enum Spielkarte As Long
|
| Karo = 9
|
| Herz = 10
|
| Pik = 11
|
| Kreuz = 12
|
| End Enum
|
Wir können in solchen Fällen nicht mit einer herkömmlichen For-Schleife operieren, sondern müssen dazu die For Each-Schleife benutzen, die ein Array elementweise durchläuft. Dieses Array müssen wir uns noch besorgen.
Eingangs wurde bereits erwähnt, dass alle Enumerationen aus der Klasse Enum abgeleitet werden. Diese stellt mit GetValues eine statische Methode zur Verfügung, die uns eine Array-Referenz aller in der Aufzählung enthaltenen Konstanten zurückliefert. GetValues ist wie folgt definiert:
| Public Shared Function GetValues(enumType As Type) As Array
|
Der Rückgabewert ist vom Typ Array, das Übergabeargument vom Typ Type. Dieser Typ liefert Informationen über einen Datentyp, beispielsweise über die von einer Klasse veröffentlichten Methoden und Felder. Dazu müssen wir uns nur den beschreibenden Type eines bestimmten Datentyps besorgen. Hier hilft die VB-spezifische Operator GetType weiter, dem wir als Argument den Typbezeichner übergeben. Der Ausdruck
| [Enum].GetValues(GetType(Spielkarte))
|
liefert die Elemente der Enumeration als Array, das wir mit karte vom ersten bis zum letzten Element durchlaufen. Bei jedem Schleifendurchlauf zeigt karte auf eine andere Konstante, deren Namen wir an der Konsole ausgeben lassen.
Beachten Sie, dass zur Unterscheidung des VB-spezifischen Schlüsselworts Enum von der Klasse Enum Letztere in eckigen Klammern angegeben werden muss.
|
